package com.hgkj.cloud.base.scheme.table;

import com.hgkj.cloud.base.scheme.*;

import java.math.BigDecimal;
import java.util.Map;

/**
 * 十二、90项症状清单（Scl90）共90题
 */
public class Table12 extends AbstractTable implements TableCalculate{
    String code = "Scl90";

    @Override
    public String getCode() {
        return code;
    }

    @Override
    public ClsAnswerResult calc(ClsAnswerRequest answer) {
        return GetScl90FactorScore(answer);
    }

    @Override
    public String[] report(Map map) {
        return null;
    }

    private static ClsAnswerResult GetScl90FactorScore(ClsAnswerRequest answer) {
        ClsAnswerResult result = new ClsAnswerResult();
        result.setMessage("");
        result.setType(answer.getType());
        result.setUuid(answer.getUuid());
        try {
            // 1总分，2总均分，3阴性项目数，4阳性项目数，5阳性项目平均分，6躯体化，7强迫症状，8人际关系，9抑郁，10焦虑，11敌对，12恐怖，13偏执，14精神病性，15其它
            // 1正确题数
            int MAX_NUM = 90;

            int intI;
            String[] strAnswer_c = answer.getAnswer().split(g_sChar);
            if (strAnswer_c.length > 1) {
                for (intI = 1; intI < strAnswer_c.length; intI++) {
                    strAnswer_c[intI] = strAnswer_c[intI].trim();
                }
            }

            String[] sAnswer = strAnswer_c[0].toString().split(g_nChar);

            if (sAnswer.length != MAX_NUM) {
                result.setMessage("答案数量不符！");
                return result;
            }

            String effective_result = null;
            if (answer.getAnswer_seconds() != null) {
                ClsEffective effective = new ClsEffective();
                effective_result = effective.GetScl90Effective(answer.getAnswer(), answer.getAnswer_seconds());
            }

            int i, j;

            // 前5个，可以在程序中计算得出
            // 后的6-15的因子，共一组，1,2,3,4,5
            // 1躯体化，2强迫症状，3人际关系，4抑郁，5焦虑，6敌对，7恐怖，8偏执，9精神病性，10其它
            String[] strNumberA = { "1,4,12,27,40,42,48,49,52,53,56,58", "3,9,10,28,38,45,46,51,55,65",
                    "6,21,34,36,37,41,61,69,73", "5,14,15,20,22,26,29,30,31,32,54,71,79",
                    "2,17,23,33,39,57,72,78,80,86", "11,24,63,67,74,81", "13,25,47,50,70,75,82", "8,18,43,68,76,83",
                    "7,16,35,62,77,84,85,87,88,90", "19,44,59,60,64,66,89" };
            String[] strSubA;

            // 诊断结果，6-15因子
            String[] vAppraiseA = new String[15];

            // 指导意见，6-14因子
            String[] vDoctorIdeaA = new String[15];

            float[][] vFactorA = new float[15][2]; // 实际为15个因子
            for (i = 0; i < vFactorA.length; i++) {
                for (j = 0; j < vFactorA[1].length; j++) {
                    vFactorA[i][j] = 0;
                }
            }

            // 原始分
            // 6-15的因子
            for (i = 0; i < strNumberA.length; i++) {
                strSubA = strNumberA[i].split(",");
                for (j = 0; j < strSubA.length; j++) {
                    vFactorA[i + 5][0] += Integer.valueOf(sAnswer[Integer.valueOf(strSubA[j]) - 1]);
                    // 3阴性项目数(24.92±18.41)
                    if (Integer.valueOf(sAnswer[Integer.valueOf(strSubA[j]) - 1]) == 1) {
                        vFactorA[2][0] += 1;
                    }
                }
                // 平均分
                BigDecimal bd1 = new BigDecimal(vFactorA[i + 5][0] / (strSubA.length));
                vFactorA[i + 5][1] = bd1.setScale(2, BigDecimal.ROUND_HALF_UP).floatValue();
                // 1总分(129.96±38.76)
                vFactorA[0][0] += vFactorA[i + 5][0];
            }

            // 2总均分(1.44±0.43)
            BigDecimal bd2 = new BigDecimal(vFactorA[0][0] / 90);
            vFactorA[1][0] = bd2.setScale(2, BigDecimal.ROUND_HALF_UP).floatValue();
            // 4阳性项目数(65.08±18.33)
            vFactorA[3][0] = 90 - vFactorA[2][0];
            // 5阳性项目平均分(2.60±0.59")
            if (vFactorA[3][0] > 0) {
                BigDecimal bd3 = new BigDecimal((vFactorA[0][0] - vFactorA[2][0]) / vFactorA[3][0]);
                vFactorA[4][0] = bd3.setScale(2, BigDecimal.ROUND_HALF_UP).floatValue();
            } else {
                vFactorA[4][0] = 1;
            }

            // 这段代码的修正很关键，依据专家建议，修改了评分常模
            /*
             * // 按6-15因子的平均分得到“诊断结果” // 按6-14因子的平均分得到“指导意见” String[] strValueA = { "无",
             * "轻", "中", "重", "极重" }; float[] sngValueA = { 1.5f, 2.5f, 3.5f, 4.5f }; for (i
             * = 0; i < 10; i++) { vAppraiseA[i + 5] = strValueA[strValueA.length - 1];
             * vDoctorIdeaA[i + 5] = "Scl90." + String.valueOf(i + 1) + ".5"; for (j = 0; j
             * < sngValueA.length; j++) { if (vFactorA[i + 5][1] < sngValueA[j]) {
             * vAppraiseA[i + 5] = strValueA[j]; vDoctorIdeaA[i + 5] = "Scl90." +
             * String.valueOf(i + 1) + "." + String.valueOf(j + 1); break; } } }
             */

            // 以下代码调整了计分常模
            // 按6-15因子的平均分得到“诊断结果”
            // 按6-14因子的平均分得到“指导意见”
            String[] strValueA = { "无", "轻", "中", "重", "极重" };
            float[][] sngValueA;
            // 司法版本沿用以前的常模标准
            if (answer.getScl() == 0) {
                sngValueA = new float[][] { { 1.5f, 2.5f, 3.5f, 4.5f }, { 1.5f, 2.5f, 3.5f, 4.5f },
                        { 1.5f, 2.5f, 3.5f, 4.5f }, { 1.5f, 2.5f, 3.5f, 4.5f }, { 1.5f, 2.5f, 3.5f, 4.5f },
                        { 1.5f, 2.5f, 3.5f, 4.5f }, { 1.5f, 2.5f, 3.5f, 4.5f }, { 1.5f, 2.5f, 3.5f, 4.5f },
                        { 1.5f, 2.5f, 3.5f, 4.5f }, { 1.5f, 2.5f, 3.5f, 4.5f } };
            } else if (answer.getAge() >= 12f && answer.getAge() < 15f) // 初中常模
            {
                sngValueA = new float[][] { { 1.92f, 2.32f, 2.66f, 3.05f }, { 2.4f, 2.87f, 3.27f, 3.72f },
                        { 2.28f, 2.77f, 3.19f, 3.66f }, { 2.17f, 2.66f, 3.07f, 3.52f }, { 2.11f, 2.57f, 2.97f, 3.41f },
                        { 2.28f, 2.77f, 3.19f, 3.66f }, { 2.17f, 2.66f, 3.07f, 3.52f }, { 2.11f, 2.57f, 2.97f, 3.41f },
                        { 2.37f, 2.92f, 3.4f, 3.92f }, { 1.95f, 2.39f, 2.77f, 3.19f }, { 2.16f, 2.63f, 3.03f, 3.48f },
                        { 2.01f, 2.43f, 2.79f, 3.2f }, { 2.14f, 2.6f, 3f, 3.44f } };
            } else if (answer.getAge() >= 15f && answer.getAge() <= 18f) // 高中常模
            {
                sngValueA = new float[][] { { 1.97f, 2.37f, 2.71f, 3.1f }, { 2.61f, 3.1f, 3.51f, 3.96f },
                        { 2.42f, 2.92f, 3.34f, 3.82f }, { 2.32f, 2.81f, 3.23f, 3.7f }, { 2.22f, 2.68f, 3.08f, 3.52f },
                        { 2.48f, 3.05f, 3.53f, 4.07f }, { 1.87f, 2.27f, 2.6f, 3.0f }, { 2.29f, 2.76f, 3.16f, 3.61f },
                        { 2.12f, 2.54f, 2.9f, 3.31f }, { 2.25f, 2.74f, 3.15f, 3.6f } };
            } else // 全国常模
            {
                sngValueA = new float[][] { { 1.79f, 2.14f, 2.44f, 2.78f }, { 2.1f, 2.52f, 2.87f, 3.27f },
                        { 1.92f, 2.32f, 2.65f, 3.02f }, { 1.9f, 2.27f, 2.59f, 2.95f }, { 1.67f, 1.98f, 2.25f, 2.55f },
                        { 1.92f, 2.33f, 2.68f, 3.07f }, { 1.6f, 1.91f, 2.18f, 2.48f }, { 1.84f, 2.21f, 2.53f, 2.89f },
                        { 1.66f, 1.97f, 2.24f, 2.54f }, { 1.83f, 2.19f, 2.5f, 2.84f } };
            }

            for (i = 0; i < 10; i++) {
                vAppraiseA[i + 5] = strValueA[strValueA.length - 1];
                vDoctorIdeaA[i + 5] = "Scl90." + String.valueOf(i + 1) + ".5";
                for (j = 0; j < sngValueA[i].length; j++) {
                    if (vFactorA[i + 5][1] < sngValueA[i][j]) {
                        vAppraiseA[i + 5] = strValueA[j];
                        vDoctorIdeaA[i + 5] = "Scl90." + String.valueOf(i + 1) + "." + String.valueOf(j + 1);
                        break;
                    }
                }
            }

            // 以下代码用于确定方案需要用到的因子等级，题目序号，题目等级
            // 首先、判断所有因子哪一个或哪几个的程度等级最高，一个就选它，多个并列就随机选择其中一个作为计算因子
            // 其次、获取选中因子对应的所有题目，判断题目中哪一个或哪几个的选项等级最高，一个就选这一题，多个就随机多个中一个，作为需要算方案的题目
            // 最后、将选中因子的等级、因子的名称、因子对应题目被选中的题目序号、题目等级，返回给接口。
            // **********************************************************************
            // 1躯体化，2强迫症状，3人际关系，4抑郁，5焦虑，6敌对，7恐怖，8偏执，9精神病性，10其它
            //// 因子等级
            int intfactor_level = 0;
            String strfactor_name = "";
            // 题目序号
            int intsort = 0;
            // 题目等级
            int intfaq_level = 0;
            // 临时记录10个因子的程度
            int[] vAppraiseATemp = new int[10];
            // 最大因子（题目）等级所在数组中的序号位置
            String strIndexTemp = "";
            // 最大因子（题目）等级所在数组中的序号位置组成的数组
            String[] strIndex;
            // 最后确定要计算的因子（题目）序号
            int intIndex = 0;
            // 需要计算因子对应的题目序号数组
            String[] strNumberB;

            String[] strfactor_nameA = { "躯体化", "强迫症状", "人际关系", "抑郁", "焦虑", "敌对", "恐怖", "偏执", "精神病性", "其他症状" };

            for (i = 0; i < 10; i++) {
                switch (vAppraiseA[i + 5]) {
                    case "无":
                        vAppraiseATemp[i] = 0;
                        break;
                    case "轻":
                        vAppraiseATemp[i] = 1;
                        break;
                    case "中":
                        vAppraiseATemp[i] = 2;
                        break;
                    case "重":
                        vAppraiseATemp[i] = 3;
                        break;
                    case "极重":
                        vAppraiseATemp[i] = 4;
                        break;
                    default: // 以防万一，不可能出现这个情况
                        vAppraiseATemp[i] = 0;
                        break;
                }
                // 顺便找出因子等级最大值
                if (vAppraiseATemp[i] >= intfactor_level) {
                    intfactor_level = vAppraiseATemp[i];
                }
            }
            // 如果最大因子等级为0，说明正常，无需计算
            if (intfactor_level == 0) {
                intfactor_level = 0;
                intsort = 0;
                intfaq_level = 1;
            } else // 找出最大值所在位置，可能是并列多个
            {
                strIndexTemp = "";
                for (i = 0; i < 10; i++) {
                    if (vAppraiseATemp[i] == intfactor_level) {
                        strIndexTemp += String.valueOf(i) + ",";
                    }
                }
                // 去掉最后一个“,”
                if (strIndexTemp.length() > 0) {
                    strIndexTemp = strIndexTemp.substring(0, strIndexTemp.length() - 1);
                    strIndex = strIndexTemp.split(",");

                    // 随机数生成例子
                    // java.util.Random random=new java.util.Random();// 定义随机类
                    // int result=random.nextInt(10);// 返回[0,10)集合中的整数，注意不包括10
                    // return result+1; // +1后，[0,10)集合变为[1,11)集合，满足要求

                    // 生成随机数
                    java.util.Random r = new java.util.Random();
                    intIndex = Integer.valueOf(strIndex[r.nextInt(strIndex.length)]);
                    strfactor_name = strfactor_nameA[intIndex];
                    // 将需要最后查找的因子对应的题目序号存储为数组
                    strNumberB = strNumberA[intIndex].split(",");
                    // 找到题目的最大等级
                    for (i = 0; i < strNumberB.length; i++) {
                        if (Integer.valueOf(sAnswer[Integer.valueOf(strNumberB[i]) - 1]) >= intfaq_level) {
                            intfaq_level = Integer.valueOf(sAnswer[Integer.valueOf(strNumberB[i]) - 1]);
                        }
                    }
                    // 找到哪些题目满足最大等级，记录题目的序号
                    strIndexTemp = "";
                    for (i = 0; i < strNumberB.length; i++) {
                        if (Integer.valueOf(sAnswer[Integer.valueOf(strNumberB[i]) - 1]) == intfaq_level) {
                            strIndexTemp += strNumberB[i] + ",";
                        }
                    }
                    if (strIndexTemp.length() > 0) {
                        strIndexTemp = strIndexTemp.substring(0, strIndexTemp.length() - 1);
                        strIndex = strIndexTemp.split(",");
                        // 生成随机数
                        java.util.Random rfaq = new java.util.Random();
                        intIndex = rfaq.nextInt(strIndex.length);

                        intsort = Integer.valueOf(strIndex[intIndex]);
                    }

                }
            }
            // **********************************************************************

            ClsScore.Scl90 scl90 = new ClsScore.Scl90();
            scl90.setTotal_o(vFactorA[0][0]);

            scl90.setTotal_ave(vFactorA[1][0]);

            scl90.setNst_o(vFactorA[2][0]);

            scl90.setPst_o(vFactorA[3][0]);

            scl90.setPst_ave(vFactorA[4][0]);

            scl90.setSom_o(vFactorA[5][0]);
            scl90.setSom_ave(vFactorA[5][1]);
            scl90.setSom_a(vAppraiseA[5]);
            scl90.setSom_d(vDoctorIdeaA[5]);

            scl90.setObs_o(vFactorA[6][0]);
            scl90.setObs_ave(vFactorA[6][1]);
            scl90.setObs_a(vAppraiseA[6]);
            scl90.setObs_d(vDoctorIdeaA[6]);

            scl90.setInt_o(vFactorA[7][0]);
            scl90.setInt_ave(vFactorA[7][1]);
            scl90.setInt_a(vAppraiseA[7]);
            scl90.setInt_d(vDoctorIdeaA[7]);

            scl90.setDep_o(vFactorA[8][0]);
            scl90.setDep_ave(vFactorA[8][1]);
            scl90.setDep_a(vAppraiseA[8]);
            scl90.setDep_d(vDoctorIdeaA[8]);

            scl90.setAnx_o(vFactorA[9][0]);
            scl90.setAnx_ave(vFactorA[9][1]);
            scl90.setAnx_a(vAppraiseA[9]);
            scl90.setAnx_d(vDoctorIdeaA[9]);

            scl90.setHos_o(vFactorA[10][0]);
            scl90.setHos_ave(vFactorA[10][1]);
            scl90.setHos_a(vAppraiseA[10]);
            scl90.setHos_d(vDoctorIdeaA[10]);

            scl90.setPno_o(vFactorA[11][0]);
            scl90.setPno_ave(vFactorA[11][1]);
            scl90.setPno_a(vAppraiseA[11]);
            scl90.setPno_d(vDoctorIdeaA[11]);

            scl90.setPar_o(vFactorA[12][0]);
            scl90.setPar_ave(vFactorA[12][1]);
            scl90.setPar_a(vAppraiseA[12]);
            scl90.setPar_d(vDoctorIdeaA[12]);

            scl90.setPsy_o(vFactorA[13][0]);
            scl90.setPsy_ave(vFactorA[13][1]);
            scl90.setPsy_a(vAppraiseA[13]);
            scl90.setPsy_d(vDoctorIdeaA[13]);

            scl90.setOther_o(vFactorA[14][0]);
            scl90.setOther_ave(vFactorA[14][1]);
            scl90.setOther_a(vAppraiseA[14]);
            if (effective_result != null)
                scl90.setEffect(effective_result);
            result.setObject(scl90);

            ClsFaqMsg faq_msg = new ClsFaqMsg();
            faq_msg.setFactor_level(intfactor_level);
            faq_msg.setSort(intsort);
            faq_msg.setFaq_level(intfaq_level - 1); // 这里减去1，是因为等级约定0-4
            faq_msg.setFactor_name(strfactor_name);
            result.setFaq_msg(faq_msg);
            ;

            return result;
        } catch (ArithmeticException e) {
            result.setMessage(e.toString());
            return result;
        }
    }

}
